import {_decorator, Component, Node, Vec3, EventTarget} from 'cc';
import {Draggable} from "db://assets/app-bundle/app-view/page/game/native/expansion/Draggable";
import {MahjongTile} from "db://assets/app-bundle/app-view/page/game/native/PageGame";
import {app} from "db://assets/app/app";

const {ccclass, property} = _decorator;

// 排序方向枚举
export enum SortDirection {
    LEFT_TO_RIGHT = 0, // 从左到右
    RIGHT_TO_LEFT = 1, // 从右到左
    TOP_TO_BOTTOM = 2, // 从上到下
    BOTTOM_TO_TOP = 3, // 从下到上
}

@ccclass('AutoSortArea')
export class AutoSortArea extends Component {
    @property({
        tooltip: '子节点之间的水平间距'
    })
    spacingX: number = 50; // 默认水平间距

    @property({
        tooltip: '子节点之间的垂直间距'
    })
    spacingY: number = 50; // 默认垂直间距

    @property({
        tooltip: '排列的起始 X 坐标'
    })
    startX: number = -200; // 默认起始 X 坐标

    @property({
        tooltip: '排列的起始 Y 坐标'
    })
    startY: number = 100; // 默认起始 Y 坐标

    @property({
        tooltip: '排序方向',
        type: Number, // ✅ 使用 Number 类型，因为枚举底层是数字
        visible: true
    })
    sortDirection: SortDirection = SortDirection.LEFT_TO_RIGHT; // 默认从左到右排序
    targetMahjongTile: MahjongTile = null //接受目标麻将

    private _eventTarget: EventTarget = new EventTarget(); // 用于监听子节点事件

    start() {
        // 在 start 中调用一次排序（可选，确保初始状态正确）
        this.sortChildren();

        // 注册子节点添加和移除事件的监听器
        this.node.on(Node.EventType.CHILD_ADDED, this.onChildAdded, this);
        this.node.on(Node.EventType.CHILD_REMOVED, this.onChildRemoved, this);
    }

    onDestroy() {
        // 移除事件监听，防止内存泄漏
        this.node.off(Node.EventType.CHILD_ADDED, this.onChildAdded, this);
        this.node.off(Node.EventType.CHILD_REMOVED, this.onChildRemoved, this);

    }

    /**
     * 手动触发排序
     */
    public sortChildren() {
        // 获取所有子节点
        const children = this.node.children;

        if (children.length === 0) {
            console.log('AutoSortArea：没有子节点，无需排序');
            return;
        }

        // 按照指定规则对子节点进行排序
        const sortedChildren = this.sortNodesByPosition(children);

        // 根据排序结果重新排列子节点位置
        this.arrangeChildren(sortedChildren);
    }

    /**
     * 子节点被添加时的回调
     */
    private onChildAdded(child: Node) {
        console.log(`AutoSortArea：检测到子节点被添加: ${child.name}`);
        child.getComponent(Draggable).onSortInArea = () => {
            this.sortChildren()
        }
        //达到三个消除
        if (this.node.children.length == 3) {
            console.log('消除')
            this.targetMahjongTile = null
            this.node.removeAllChildren()
            app.manager.sound.playEffect({name: 'effect/overThree'})
        }
        this.sortChildren(); // 自动触发排序
    }

    /**
     * 子节点被移除时的回调
     */
    private onChildRemoved(child: Node) {
        console.log(`AutoSortArea：检测到子节点被移除: ${child.name}`);
        this.sortChildren(); // 自动触发排序
    }

    /**
     * 根据当前排序方向对子节点进行排序
     */
    private sortNodesByPosition(children: Node[]): Node[] {
        return children.slice().sort((a, b) => {
            switch (this.sortDirection) {
                case SortDirection.LEFT_TO_RIGHT:
                    // 按照节点的 position.x 从小到大排序（从左到右）
                    return a.position.x - b.position.x;
                case SortDirection.RIGHT_TO_LEFT:
                    // 按照节点的 position.x 从大到小排序（从右到左）
                    return b.position.x - a.position.x;
                case SortDirection.TOP_TO_BOTTOM:
                    // 按照节点的 position.y 从大到小排序（从上到下）
                    return b.position.y - a.position.y;
                case SortDirection.BOTTOM_TO_TOP:
                    // 按照节点的 position.y 从小到大排序（从下到上）
                    return a.position.y - b.position.y;
                default:
                    // 默认按照 position.x 从小到大排序
                    return a.position.x - b.position.x;
            }
        });
    }

    /**
     * 根据排序结果重新排列子节点位置
     */
    private arrangeChildren(sortedChildren: Node[]) {
        let currentX = this.startX;
        let currentY = this.startY;

        for (const child of sortedChildren) {
            // 设置子节点位置
            child.setPosition(currentX, currentY, 0);

            // 根据排序方向更新下一个节点的位置
            switch (this.sortDirection) {
                case SortDirection.LEFT_TO_RIGHT:
                    // 从左到右排列，x 增加，y 不变
                    currentX += this.spacingX;
                    break;
                case SortDirection.RIGHT_TO_LEFT:
                    // 从右到左排列，x 减少，y 不变
                    currentX -= this.spacingX;
                    break;
                case SortDirection.TOP_TO_BOTTOM:
                    // 从上到下排列，y 减少，x 不变
                    currentY -= this.spacingY;
                    break;
                case SortDirection.BOTTOM_TO_TOP:
                    // 从下到上排列，y 增加，x 不变
                    currentY += this.spacingY;
                    break;
            }
        }

        console.log('AutoSortArea：子节点已重新排列');
    }
}